
#ifndef MYARRAY_H
#define MYARRAY_H
/*************************************************
  * 描述：
  *
  * File：MyArray.h
  * Author：name@mozihealthcare.cn
  * Date：2025-07-18
  * Update：
  * ************************************************/

#include <iostream>
using namespace std;

const int INIT_SIZE=16;
const float RESIZE_FACTOR=0.75;
template <typename T>
class MyArray
{
private:
    T* arr;
    int length;
    int size;

    // 封装通用方法，实现数组元素位置的整体移动
    void offsetArray(int index, bool add);
    // 扩容
    void resize();

public:
    // 构造函数
    MyArray();
    MyArray(int maxSize);

    // 初始化数组
    void init(T* temp, int len);
    // 末尾添加元素
    void add(T data);
    // 在具体位置插入元素
    void add(T data, int index);
    // 根据数据或者索引删除数据
    void del(T data);
    // 根据数据查找索引位置或者根据索引查询具体元素
    int find_first(T data, bool byIndex) const;
    // 更新特定元素
    void update(T oldData, T newData);
    // 更新特定位置的元素
    void update(int index,T data, bool byIndex);
    // 获取数组长度
    int getLength() const;
    // 获取数组大小
    int getSize() const;
    // 打印数组
    void print() const;
    // 清空数组
    void clear();
    // 判断元素是否存在
    T* getArr() const;
    // 析构函数
    ~MyArray();
};

// 构造函数
template <typename T>
MyArray<T>::MyArray():MyArray(INIT_SIZE) {

}

template <typename T>
MyArray<T>::MyArray(int maxSize) {
    size = maxSize;
    arr = new T[size]();
    length = 0;
}

// 初始化数组
template <typename T>
void MyArray<T>::init(T* temp, int len) {
    if (temp == nullptr || len < 0) return;
    for (int i = 0; i < len; i++) {
        arr[i] = temp[i];
    }
    length = len;
}

// 末尾添加元素
template <typename T>
void MyArray<T>::add(T data) {
    if (arr==nullptr)
        arr = new T[size];
    arr[length] = data;
    ++length;
    resize();
}

// 在指定位置插入元素
template <typename T>
void MyArray<T>::add(T data, int index) {
    if (arr==nullptr)
        arr = new T[size];
    offsetArray(index, true);
    arr[index] = data;
    ++length;
    resize();
}

// 删除元素（按值或按索引）
template <typename T>
void MyArray<T>::del(T data) {
    T* newArr = new T[size];
    int cnt = 0;
    for (int i = 0; i < length; i++) {
        if (arr[i] != data) {
            newArr[cnt++] = arr[i];
        }
    }
    delete[] arr;
    arr = newArr;
    length = cnt;
}

// 查找元素（按值或按索引）
template <typename T>
int MyArray<T>::find_first(T data, bool byIndex) const {
    if (byIndex) {
        if (data >= 0 && data < length) { // 修正：原代码逻辑错误，按索引查找应直接返回索引
            return data; // 错误：应返回索引，而非值
        }
    } else {
        for (int i = 0; i < length; ++i) {
            if (arr[i] == data) {
                return i;
            }
        }
    }
    return -1;
}

// 更新元素（按值或按索引）
template <typename T>
void MyArray<T>::update(T oldData, T newData) {
    for (int i = 0; i < length; ++i) {
        if (*arr[i] == *oldData) {
            arr[i] = newData;
        }
    }
}

template <typename T>
void MyArray<T>::update( int index,T data,bool byIndex) {
    if (byIndex) {
        if (index >= 0 && index < length) { // 修正：原代码逻辑错误，索引越界检查
            arr[index] = data;
        }
    }
}

// 数组元素整体移动（用于插入/删除）
template <typename T>
void MyArray<T>::offsetArray(int index, bool add) {
    if (index < 0 || index >= length) return;
    if (add) {
        for (int i = length; i > index; --i) {
            arr[i] = arr[i - 1];
        }
    } else {
        for (int i = index; i < length - 1; ++i) {
            arr[i] = arr[i + 1];
        }
        length--;
    }
}

// 扩容逻辑
template <typename T>
void MyArray<T>::resize() {
    if (length >= size * RESIZE_FACTOR) {
        size *= 2;
        T* newArr = new T[size];
        for (int i = 0; i < length; ++i) {
            newArr[i] = arr[i];
        }
        delete[] arr;
        arr = newArr;
    }
}

// 获取数组长度和大小
template <typename T>
int MyArray<T>::getLength() const {
    return length;
}

template <typename T>
int MyArray<T>::getSize() const {
    return size;
}

// 打印数组
template <typename T>
void MyArray<T>::print() const {
    for (int i = 0; i < length; ++i) {
        cout << arr[i] << "\t";
    }
    cout << endl;
}

template<typename T>
void MyArray<T>::clear() {
    length=0;
    size=INIT_SIZE;
    delete[] arr;
}

template<typename T>
T * MyArray<T>::getArr() const {
    return arr;
}

// 析构函数
template <typename T>
MyArray<T>::~MyArray() {
    delete[] arr;
}

#endif // MYARRAY_H
